{"componentChunkName":"component---src-templates-post-jsx","path":"/[JPA]7/","result":{"data":{"site":{"siteMetadata":{"title":"SUbbb"}},"markdownRemark":{"id":"26e75089-52ac-5b50-98c9-c2806068b034","excerpt":"자바 ORM 표준 JPA 프로그래밍 - 김영한을 읽고 인용하고 정리하는 POST입니다. 상속 관계 매핑: 객체의 상속 관계를 데이터베이스에 어떻게 매핑하는가?\n: 등록일, 수정일 같이 여러 엔티티에서 공통으로 사용하는 매핑 정보만 상속받고 싶으면 이 기능을 사용\n복합 키와 식별 관계 매핑: 데이터베이스의 식별자가 하나 이상일 때 매핑하는 방법\n조인 테이블…","html":"<p><em>[자바 ORM 표준 JPA 프로그래밍 - 김영한]을 읽고 인용하고 정리하는 POST입니다.</em></p>\n<blockquote>\n<p>상속 관계 매핑: 객체의 상속 관계를 데이터베이스에 어떻게 매핑하는가?\n<code class=\"language-text\">@MappedSuperclass</code>: 등록일, 수정일 같이 여러 엔티티에서 공통으로 사용하는 매핑 정보만 상속받고 싶으면 이 기능을 사용\n복합 키와 식별 관계 매핑: 데이터베이스의 식별자가 하나 이상일 때 매핑하는 방법\n조인 테이블: 테이블은 외래 키 하나로 연관관계가 가능하지만 연관관계를 관리하는 연결 테이블을 두는 방법도 존재\n엔티티 하나에 여러 테이블 매핑: 엔티티 하나에 테이블 하나를 매핑하지 않고 엔티티 하나에 여러 테이블을 매핑</p>\n</blockquote>\n<h2>💫 상속 관계 매핑</h2>\n<p>관계형 데이터베이스에는 객체지향 언어에서 다루는 상속이라는 개념이 없다. 그 대신 슈퍼타입 관계(Super-Type Sub-Type Relationship)라는 모델링 기법이 유사한 기능을 한다. <strong>ORM에서 다루는 상속 관계 매핑</strong>은 <strong>객체의 상속 구조와 데이터베이스의 슈퍼타입 서브타입 관계를 매핑</strong>하는 것이다.</p>\n<p>슈퍼타입 서브타입 논리 모델을 실제 물리 모델인 테이블로 구현하는 방법</p>\n<ul>\n<li>\n<p>각각의 테이블로 변환</p>\n<ul>\n<li>각각을 모두 테이블로 만들고 조회할 때 조인을 사용 = 조인 전략</li>\n</ul>\n</li>\n<li>\n<p>통합 테이블로 변환</p>\n<ul>\n<li>테이블을 하나만 사용해 통합 = 단일 테이블 전략</li>\n</ul>\n</li>\n<li>\n<p>서브타입 테이블로 변환</p>\n<ul>\n<li>서브 타입마다 하나의 테이블을 생성 = 구현 클래스마다 테이블 전략</li>\n</ul>\n</li>\n</ul>\n<h3>➰ 조인 전략</h3>\n<p>엔티티 <strong>각각을 모두 테이블</strong>로 만들고 자식 테이블이 부모 테이블의 기본 키를 받아 <strong>기본 키 + 외래 키</strong>로 사용하는 전략</p>\n<ul>\n<li>조회 시 조인을 사용</li>\n<li>객체는 <strong>타입 구분이 가능</strong>하지만, 테이블은 타입 개념이 없어 <strong>타입을 구분하는 컬럼의 추가가 필요</strong></li>\n</ul>\n<deckgo-highlight-code language=\"java\" terminal=\"carbon\" theme=\"a11y-dark\" line-numbers=\"true\"  >\n          <code slot=\"code\">@Entity\n@Inheritance(strategy = InheritanceType.JOINED)\n@DiscriminatorColumn(name = &quot;DTYPE&quot;)\npublic abstract class Item {\n\n  @Id @GeneratedValue\n  @Column(name = &quot;ITEM_ID&quot;)\n  private Long id;\n\n  private String name;\n  private int price;\n  ...\n\n}\n\n@Entity\n@DiscriminatorValue(&quot;A&quot;)\npublic class Album extends Item {\n  \n  private String artist;\n  ...\n\n}\n\n@Entity\n@DiscriminatorValue(&quot;M&quot;)\npublic class Movie extends Item {\n\n  private String director;\n  private String actor;\n  ...\n\n}</code>\n        </deckgo-highlight-code>\n<ul>\n<li>\n<p><code class=\"language-text\">@Inheritance(strategy = InheritanceType.JOINED)</code></p>\n<ul>\n<li>상속 매핑은 부모 클래스에 이 annotation을 사용해야 한다.</li>\n<li>그리고 매핑 전략은 조인 전략을 사용한다는 것을 명시한다.</li>\n</ul>\n</li>\n<li>\n<p><code class=\"language-text\">@DiscriminatorColumn(name = \"DTYPE\")</code></p>\n<ul>\n<li>부모 클래스에 구분 컬럼을 지정한다.</li>\n<li>이 컬럼으로 저장된 자식 테이블을 구분한다.</li>\n</ul>\n</li>\n<li>\n<p><code class=\"language-text\">@DiscriminatorValue(\"A\")</code></p>\n<ul>\n<li>엔티티를 저장할 떄 구분 컬럼에 입력할 값을 지정한다.</li>\n</ul>\n</li>\n</ul>\n<p><strong>장점</strong></p>\n<ul>\n<li>테이블이 정규화된다.</li>\n<li>외래 키 참조 무결성 제약조건을 활용할 수 있다.</li>\n<li>저장공간을 효율적으로 사용한다.</li>\n</ul>\n<p><strong>단점</strong></p>\n<ul>\n<li>조인을 많이 사용하여 조회 쿼리가 복잡하고, 성능이 저하될 수 있다.</li>\n<li>데이터를 등록할 INSERT SQL을 두 번 실행한다.</li>\n</ul>\n<p><strong>특징</strong></p>\n<ul>\n<li>JPA 표준 명세는 구분 컬럼을 사용하도록 하지만, 몇몇 구현체는 생략해도 동작한다.</li>\n</ul>\n<h3>➰ 단일 테이블 전략</h3>\n<p>테이블을 하나만 사용한다. 그리고 구분 컬럼으로 어떤 자식 데이터가 저장되었는지 확인하고, 단일 테이블이므로 조인을 사용하지 않아 일반적으로 가장 빠르다.</p>\n<p><strong>주의점</strong></p>\n<ul>\n<li>자식 엔티티가 매핑한 컬럼은 모두 <code class=\"language-text\">null</code> 을 허용해야 한다. (<code class=\"language-text\">NOT NULL</code> X)</li>\n<li>특정 자식 엔티티를 저장할 때, 다른 자식 엔티티와 매핑된 컬럼들은 사용하지 않아 <code class=\"language-text\">null</code> 이 입력되기 때문이다.</li>\n</ul>\n<deckgo-highlight-code language=\"java\" terminal=\"carbon\" theme=\"a11y-dark\" line-numbers=\"true\"  >\n          <code slot=\"code\">@Entity\n@Inheritance(strategy = InheritanceType.SINGLE_TABLE)\n@DiscriminatorColumn(name = &quot;DTYPE&quot;)\npublic abstract class Item {\n\n  @Id @GeneratedValue\n  @Column(name = &quot;ITEM_ID&quot;)\n  private Long id;\n\n  private String name;\n  private int price;\n  ...\n\n}\n\n@Entity\n@DiscriminatorValue(&quot;A&quot;)\npublic class Album extends Item {...}\n\n@Entity\n@DiscriminatorValue(&quot;M&quot;)\npublic class Movie extends Item {...}\n\n@Entity\n@DiscriminatorValue(&quot;B&quot;)\npublic class Book extends Item {...}</code>\n        </deckgo-highlight-code>\n<ul>\n<li>단일 테이블 전략임을 명시한다.</li>\n<li>테이블 하나에 모든 것을 통합하기에 <strong>구분 컬럼이 필수적</strong>이다.</li>\n</ul>\n<p><strong>장점</strong></p>\n<ul>\n<li>조인이 필요없어 일반적으로 조회 성능이 빠르다.</li>\n<li>조회 쿼리가 단순하다.</li>\n</ul>\n<p><strong>단점</strong></p>\n<ul>\n<li>자식 엔티티가 매핑한 컬럼은 모두 <code class=\"language-text\">null</code> 을 허용해야 한다.</li>\n<li>단일 테이블에 모든 것을 저장해 오히려 테이블이 커질 수 있다. 즉, 조회 성능이 느려질 수 있다.</li>\n</ul>\n<p><strong>특징</strong></p>\n<ul>\n<li>구분 컬럼이 필수다. (<code class=\"language-text\">@DiscriminatorColumn</code>)</li>\n<li><code class=\"language-text\">@DiscriminatorValue</code> 를 지정하지 않으면 기본으로 엔티티 이름을 사용한다.</li>\n</ul>\n<h3>➰ 구현 클래스마다 테이블 전략</h3>\n<p>자식 엔티티마다 테이블을 생성한다. 그리고 자식 테이블 각각에 필요한 컬럼이 모두 있다.</p>\n<deckgo-highlight-code language=\"java\" terminal=\"carbon\" theme=\"a11y-dark\" line-numbers=\"true\"  >\n          <code slot=\"code\">@Entity\n@Inheritance(strategy = InheritanceType.TABLE_PER_CLASS)\npublic abstract class Item {\n\n  @Id @GeneratedValue\n  @Column(name = &quot;ITEM_ID&quot;)\n  private Long id;\n\n  private String name;\n  private int price;\n  ...\n\n}\n\n@Entity\npublic class Album extends Item {...}\n\n@Entity\npublic class Movie extends Item {...}\n\n@Entity\npublic class Book extends Item {...}</code>\n        </deckgo-highlight-code>\n<ul>\n<li>구현 클래스마다 테이블 전략을 사용함을 명시한다.</li>\n<li>자식 엔티티마다 테이블을 생성한다.</li>\n</ul>\n<p><strong>장점</strong></p>\n<ul>\n<li>서브 타입을 구분해 처리 시 효과적이다.</li>\n<li><code class=\"language-text\">NOT NULL</code> 제약조건을 사용할 수 있다.</li>\n</ul>\n<p><strong>단점</strong></p>\n<ul>\n<li>여러 자식 테이블을 함께 조회할 때 성능이 느리다. (UNION 사용)</li>\n<li>자식 테이블을 통합해서 쿼리하기 어렵다.</li>\n</ul>\n<p><strong>특징</strong></p>\n<ul>\n<li>구분 컬럼을 사용하지 않는다.</li>\n</ul>\n<blockquote>\n<p>추천하지 않는 전략이다. 조인이나 단일 테이블 전략을 사용하자.</p>\n</blockquote>\n<hr>\n<h2>💫 @MappedSuperclass</h2>\n<p>부모 클래스는 테이블과 매핑하지 않고 부모 클래스를 상속받는 자식 클래스에게 매핑 정보만 제공하고 싶다면 <code class=\"language-text\">@MappedSuperclass</code> 를 사용하면 된다.</p>\n<ul>\n<li>이는 추상 클래스와 비슷한데, <code class=\"language-text\">@Entity</code> 는 실제 테이블과 매핑되지만, 이는 실제 테이블과는 매핑되지 않는다.</li>\n<li>단순히 <strong>매핑 정보를 상속할 목적으로만 사용</strong>된다.</li>\n</ul>\n<p><strong>서로 관계가 없는 테이블</strong>(<code class=\"language-text\">Member</code> &#x26; <code class=\"language-text\">Seller</code>)이지만, <strong>공통 속성</strong>을 가지는 두 객체 모델을 부모 클래스로 모으고 <strong>객체 상속 관계</strong>로 만들어보자.</p>\n<deckgo-highlight-code language=\"java\" terminal=\"carbon\" theme=\"a11y-dark\" line-numbers=\"true\"  >\n          <code slot=\"code\">@MappedSuperclass\npublic abstract class BaseEntity {\n\n  @Id @GeneratedValue\n  private Long id;\n  private String name;\n  ...\n\n}\n\n@Entity\npublic class Member extends BaseEntity {\n\n  // ID 상속\n  // NAME 상속\n  private String email;\n  ...\n\n}\n\n@Entity\npublic class Seller extends BaseEntity {\n  \n  // ID 상속\n  // NAME 상속\n  private String shopName;\n  ...\n\n}</code>\n        </deckgo-highlight-code>\n<ul>\n<li><code class=\"language-text\">BaseEntity</code> 에는 객체들이 주로 사용하는 공통 매핑 정보를 정의했다. 자식 엔티티들은 이를 상속해 사용한다.</li>\n<li>여기서 <code class=\"language-text\">BaseEntity</code> 는 테이블과 매핑할 필요가 없고 자식 엔티티들에게 공통으로 사용되는 매핑 정보만 제공하고 있다.</li>\n<li>상속받은 매핑 정보(여기서는 <code class=\"language-text\">id</code> , <code class=\"language-text\">name</code>)를 재정의하기 위해서는 <code class=\"language-text\">@AttributeOverrides</code> 나 <code class=\"language-text\">@AttributeOverride</code> 를 사용하고, 연관관계를 재정의하기 위해서는 <code class=\"language-text\">@AssociationOverrides</code> 나 <code class=\"language-text\">@AssociationOverride</code> 를 사용한다.</li>\n</ul>\n<p><strong>특징</strong></p>\n<ul>\n<li>테이블과 매핑되지 않고, 자식 클래스에 엔티티의 매핑 정보를 상속하기 위해 사용한다.</li>\n<li><code class=\"language-text\">@MappedSuperclass</code> 로 지정한 클래스는 엔티티가 아니므로 <code class=\"language-text\">em.find()</code> 나 JPQL에서 사용할 수 없다.</li>\n<li>이 클래스를 직접 생성해 사용할 일은 거의 없어 추상 클래스로 만드는 것을 권장한다.</li>\n</ul>\n<blockquote>\n<p>엔티티(<code class=\"language-text\">@Entity</code>)는 엔티티(<code class=\"language-text\">@Entity</code>)이거나 <code class=\"language-text\">@MappedSuperclass</code> 로 지정한 클래스만 상속받을 수 있다.</p>\n</blockquote>\n<hr>\n<h2>💫 복합 키와 식별 관계 매핑</h2>\n<p>복합 키를 매핑하는 방법과 식별 관계, 비식별 관계를 매핑하는 방법에 대해 다룬다.</p>\n<h3>➰ 식별 관계 vs 비식별 관계</h3>\n<p>이를 구분하는 것은 <strong>외래 키가 기본 키에 포함되는지</strong> 여부이다.</p>\n<p><strong>식별관계</strong><br/>\n부모 테이블의 기본 키를 내려받아서 자식 테이블의 기본 키 + 외래 키로 사용하는 관계</p>\n<p><strong>비식별 관계</strong><br/>\n부모 테이블의 기본 키를 받아 자식 테이블의 외래 키로만 사용하는 관계</p>\n<p>비식별 관계는 외래 키에 <code class=\"language-text\">NULL</code> 을 허용하는지에 따라 필수적 비식별 관계와 선택적 비식별 관계로 나뉜다.</p>\n<ul>\n<li>필수적 비식별 관계(Mandatory) : 외래 키에 <code class=\"language-text\">NULL</code> 을 허용하지 않는다. 연관관계를 필수적으로 맺어야 한다.</li>\n<li>선택적 비식별 관계(Optional) : 외래 키에 <code class=\"language-text\">NULL</code> 을 허용한다. 선택적으로 연관관계를 맺는다.</li>\n</ul>\n<blockquote>\n<p>최근에는 비식별 관계를 주로 사용하고, 꼭 필요한 곳에만 식별 관계를 사용하는 추세이다. JPA는 두 관계를 모두 지원한다.</p>\n</blockquote>\n<h3>➰ 복합 키: 비식별 관계 매핑</h3>\n<p>기본 키를 구성하는 컬럼이 하나면 단순하게 <code class=\"language-text\">@Id</code> 를 사용해 매핑한다.</p>\n<deckgo-highlight-code language=\"java\" terminal=\"carbon\" theme=\"a11y-dark\" line-numbers=\"true\"  >\n          <code slot=\"code\">@Entity\npublic class Hello {\n  @Id\n  private String id;\n}</code>\n        </deckgo-highlight-code>\n<p>둘 이상의 컬럼으로 구성된 복합 기본 키는 <code class=\"language-text\">@Id</code> 를 각 컬럼에 사용하는 것이 아니라 <strong>별도의 식별자 클래스</strong>가 필요하다.</p>\n<p>JPA는 영속성 컨텍스트에 엔티티를 보관할 때 엔티티의 식별자를 키로 사용한다. 그리고 식별자를 구분하기 위해 <code class=\"language-text\">equals</code> 와 <code class=\"language-text\">hashCode</code> 를 사용해 동등성 비교를 한다.</p>\n<ul>\n<li>식별자 필드가 하나일 때는 보통 자바의 기본 타입을 사용해 문제가 없다.</li>\n<li>2개 이상인 경우 별도의 식별자 클래스를 만들고, <code class=\"language-text\">equals</code> 와 <code class=\"language-text\">hashCode</code> 를 구현해야 한다.</li>\n<li>\n<p>JPA는 복합 키 지원을 위해 <code class=\"language-text\">@IdClass</code> 와 <code class=\"language-text\">@EmbeddedId</code> 2가지 방법을 제공한다.</p>\n<ul>\n<li>전자는 관계형 데이터베이스에 가까운 방법이고,</li>\n<li>후자는 객체지향에 좀 더 가까운 방법이다.</li>\n</ul>\n</li>\n</ul>\n<p><strong><code class=\"language-text\">@IdClass</code></strong><br/>\n비식별 관계의 복합 키 테이블이 있고, <code class=\"language-text\">PARENT</code> 테이블은 복합 기본 키를 사용한다. </p>\n<ul>\n<li>기본 키를 <code class=\"language-text\">PARENT_ID1</code> , <code class=\"language-text\">PARENT_ID2</code> 로 묶은 복합 키로 구성했다.</li>\n<li>따라서 별도의 식별자 클래스를 사용해 매핑해야 한다.</li>\n</ul>\n<deckgo-highlight-code language=\"java\" terminal=\"carbon\" theme=\"a11y-dark\" line-numbers=\"true\"  >\n          <code slot=\"code\">@Entity\n@IdClass(ParentId.class)\npublic class Parent {\n\n  @Id\n  @Column(name = &quot;PARENT_ID1&quot;)\n  private String id1;\n\n  @Id\n  @Column(name = &quot;PARENT_ID2&quot;)\n  private String id2;\n\n  private String name;\n  ...\n\n}</code>\n        </deckgo-highlight-code>\n<ul>\n<li>각각의 기본 키 컬럼을 <code class=\"language-text\">@Id</code> 로 매핑했다. 그리고 <code class=\"language-text\">@IdClass</code> 를 사용해 <code class=\"language-text\">ParentId</code> 클래스를 식별자 클래스로 지정했다.</li>\n</ul>\n<deckgo-highlight-code language=\"java\" terminal=\"carbon\" theme=\"a11y-dark\" line-numbers=\"true\"  >\n          <code slot=\"code\">public class ParentId implements Serializable {\n\n  private String id1;\n  private String id2;\n\n  public ParentId() {\n  }\n\n  public ParentId(String id1, String id2) {\n    this.id1 = id1;\n    this.id2 = id2;\n  }\n\n  @Override \n  public boolean equals(Object o) {...}\n\n  @Override\n  public int hashCode() {...}\n}</code>\n        </deckgo-highlight-code>\n<p><code class=\"language-text\">@IdClass</code> 를 사용할 때 식별자 클래스가 만족해야 하는 조건이 있다.</p>\n<ul>\n<li>식별자 클래스의 속성명과 엔티티에서 사용하는 식별자의 속성명이 같아야 한다.</li>\n<li><code class=\"language-text\">Serializable</code> 인터페이스를 구현해야 한다.</li>\n<li><code class=\"language-text\">equals</code> , <code class=\"language-text\">hashCode</code> 를 구현해야 한다.</li>\n<li>기본 생성자가 있어야 한다.</li>\n<li>식별자 클래스는 <code class=\"language-text\">public</code> 이어야 한다.</li>\n</ul>\n<p>실사용 예시이다. 복합 키를 사용하는 엔티티를 저장한다.</p>\n<deckgo-highlight-code language=\"java\" terminal=\"carbon\" theme=\"a11y-dark\" line-numbers=\"true\"  >\n          <code slot=\"code\">Parent parent = new Parent();\nparent.setId1(&quot;myId1&quot;);\nparent.setId2(&quot;myId2&quot;);\nparent.setName(&quot;parentName&quot;);\nem.persist(parent);</code>\n        </deckgo-highlight-code>\n<ul>\n<li>\n<p>식별자 클래스인 <code class=\"language-text\">ParentId</code> 가 보이지 않는다. </p>\n<ul>\n<li><code class=\"language-text\">em.persist()</code> 를 호출하면 영속성 컨텍스트에 엔티티를 등록하기 전 내부에서 <code class=\"language-text\">Parent.id1</code> , <code class=\"language-text\">Parent.id2</code> 값을 사용해 <code class=\"language-text\">ParentId</code> 를 생성하고 영속성 컨텍스트의 키로 사용한다.</li>\n</ul>\n</li>\n</ul>\n<p>복합 키로 조회하는 예시이다.</p>\n<deckgo-highlight-code language=\"java\" terminal=\"carbon\" theme=\"a11y-dark\" line-numbers=\"true\"  >\n          <code slot=\"code\">ParentId parentId = new ParentId(&quot;myId1&quot;, &quot;myId2&quot;);\nParent parent = em.find(Parent.class, parentId);</code>\n        </deckgo-highlight-code>\n<ul>\n<li>식별자 클래스를 사용해 엔티티를 조회한다.</li>\n</ul>\n<p>이제 자식 클래스를 추가한다.</p>\n<deckgo-highlight-code language=\"java\" terminal=\"carbon\" theme=\"a11y-dark\" line-numbers=\"true\"  >\n          <code slot=\"code\">@Entity\npublic class Child {\n\n  @Id\n  private String id;\n\n  @ManyToOne\n  @JoinColumns({\n          @JoinColumn(name = &quot;PARENT_ID1&quot;,\n              referencedColumnName = &quot;PARENT_ID1&quot;),\n          @JoinColumn(name = &quot;PARENT_ID2&quot;,\n              referencedColumnName = &quot;PARENT_ID2&quot;)\n  })\n  private Parent parent;\n}</code>\n        </deckgo-highlight-code>\n<ul>\n<li>\"부모 테이블의 기본 키 컬럼이 복합 키\"이므로 \"자식 테이블의 외래 키도 복합 키\"다.</li>\n<li>따라서 외래 키 매핑 시 여러 컬럼을 매핑해야 하므로 <code class=\"language-text\">@JoinColumns</code> 를 사용하고 각각의 외래 키 컬럼을 <code class=\"language-text\">@JoinColumn</code> 으로 매핑했다.</li>\n</ul>\n<blockquote>\n<p><code class=\"language-text\">@JoinColumn</code> 의 <code class=\"language-text\">name</code> 속성과 <code class=\"language-text\">referencedColumnName</code> 속성의 값이 같다면 <code class=\"language-text\">referencedColumnName</code> 은 생략 가능하다.</p>\n</blockquote>\n<p><strong><code class=\"language-text\">@EmbeddedId</code></strong><br/>\n좀 더 객체지향적인 방법이다.</p>\n<deckgo-highlight-code language=\"java\" terminal=\"carbon\" theme=\"a11y-dark\" line-numbers=\"true\"  >\n          <code slot=\"code\">@Entity\npublic class Parent {\n\n  @EmbeddedId\n  private ParentId id;\n\n  private String name;\n  ...\n\n}</code>\n        </deckgo-highlight-code>\n<ul>\n<li><code class=\"language-text\">Parent</code> 엔티티에서 식별자 클래스를 직접 사용하고, <code class=\"language-text\">@EmbeddedId</code> 을 사용한다.</li>\n</ul>\n<deckgo-highlight-code language=\"java\" terminal=\"carbon\" theme=\"a11y-dark\" line-numbers=\"true\"  >\n          <code slot=\"code\">@Embeddable\npublic class ParentId implements Serializable {\n\n  @Column(name = &quot;PARENT_ID1&quot;)\n  private String id1;\n  @Column(name = &quot;PARENT_ID2&quot;)\n  private String id2;\n\n  // equals, hashCode 구현\n  ...\n\n}</code>\n        </deckgo-highlight-code>\n<ul>\n<li><strong>식별자 클래스에 기본 키를 직접 매핑</strong>한다.</li>\n</ul>\n<p><code class=\"language-text\">@EmbeddedId</code> 를 사용할 때 식별자 클래스가 만족해야 하는 조건이 있다.</p>\n<ul>\n<li><code class=\"language-text\">@Embeddable</code> annotation을 붙여야 한다.</li>\n<li><code class=\"language-text\">Serializable</code> 인터페이스를 구현해야 한다.</li>\n<li><code class=\"language-text\">equals</code> , <code class=\"language-text\">hashCode</code> 를 구현해야 한다.</li>\n<li>기본 생성자가 있어야 한다.</li>\n<li>식별자 클래스는 <code class=\"language-text\">public</code> 이어야 한다.</li>\n</ul>\n<p><code class=\"language-text\">@EmbeddedId</code> 를 사용해 엔티티를 저장한다.</p>\n<deckgo-highlight-code language=\"java\" terminal=\"carbon\" theme=\"a11y-dark\" line-numbers=\"true\"  >\n          <code slot=\"code\">Parent parent = new Parent();\nParentId parentId = new ParentId(&quot;myId1&quot;, &quot;myId2&quot;);\nparent.setId(parentId);\nparent.setName(&quot;parentName&quot;);\nem.persist(parent);</code>\n        </deckgo-highlight-code>\n<ul>\n<li>식별자 클래스를 직접 생성해 사용한다.</li>\n</ul>\n<p>엔티티를 조회하는 예시이다. 조회 역시 식별자 클래스를 직접 사용한다.</p>\n<deckgo-highlight-code language=\"java\" terminal=\"carbon\" theme=\"a11y-dark\" line-numbers=\"true\"  >\n          <code slot=\"code\">ParentId parentId = new ParentId(&quot;myId1&quot;, &quot;myId2&quot;);\nParent parent = em.find(Parent.class, parentId);</code>\n        </deckgo-highlight-code>\n<p><strong>복합 키와 <code class=\"language-text\">equals()</code> , <code class=\"language-text\">hashCode()</code></strong><br/>\n복합 키는 해당 메소드들을 필수로 구현해야 한다.</p>\n<deckgo-highlight-code language=\"java\" terminal=\"carbon\" theme=\"a11y-dark\" line-numbers=\"true\"  >\n          <code slot=\"code\">ParentId id1 = new ParentId();\nid1.setId1(&quot;myId1&quot;);\nid1.setId2(&quot;myId2&quot;);\n\nParentId id2 = new ParentId();\nid2.setId1(&quot;myId1&quot;);\nid2.setId2(&quot;myId2&quot;);\n\nid1.equals(id2) -&gt; ???</code>\n        </deckgo-highlight-code>\n<ul>\n<li>생성한 두 인스턴스 모두 같은 값을 가지고 있지만, 인스턴스 자체는 다르다.</li>\n<li>\n<p>따라서 <code class=\"language-text\">equals()</code> 를 적절히 오버라이딩하지 않았다면 결과는 거짓이다.</p>\n<ul>\n<li>자바의 모든 클래스는 기본으로 <code class=\"language-text\">Object</code> 클래스를 상속받는데, 이 클래스가 제공하는 <strong>기본 <code class=\"language-text\">equals()</code> 는 인스턴스 참조 값 비교인 == 비교(동일성 비교)를 하기 때문</strong>이다.</li>\n</ul>\n</li>\n<li>\n<p>영속성 컨텍스트는 엔티티의 식별자를 키로 사용해 엔티티를 관리한다. 그리고 식별자 비교에 <code class=\"language-text\">equals()</code> 와 <code class=\"language-text\">hashCode()</code> 를 사용한다.</p>\n<ul>\n<li>따라서 식별자 객체의 동등성이 지켜지지 않으면 엔티티 관리에 문제가 발생하고, 이것이 위 메소드들의 필수적인 구현이 필요한 이유이다.</li>\n</ul>\n</li>\n</ul>\n<p><strong><code class=\"language-text\">@IdClass</code> vs <code class=\"language-text\">@EmbeddedId</code></strong><br/>\n둘 다 장단점이 있어 취향껏 사용하면 된다.</p>\n<blockquote>\n<p>복합 키를 구성하는 여러 컬럼 중 어느 하나에도 <code class=\"language-text\">@GeneratedValue</code> 를 사용할 수 없다.</p>\n</blockquote>\n<h3>➰ 복합 키: 식별 관계 매핑</h3>\n<p>부모, 자식, 손자까지 계속 기본 키를 전달하는 식별 관계가 있을 시, 식별 관계에서 자식 테이블은 부모 테이블의 기본 키를 포함해 복합 키를 구성해야 해서 <code class=\"language-text\">@IdClass</code> , <code class=\"language-text\">@EmbeddedId</code> 중 하나를 사용해 식별자를 매핑해야 한다.</p>\n<p><strong><code class=\"language-text\">@IdClass</code> 와 식별 관계</strong><br/></p>\n<deckgo-highlight-code language=\"java\" terminal=\"carbon\" theme=\"a11y-dark\" line-numbers=\"true\"  >\n          <code slot=\"code\">@Entity\npublic class Parent {\n\n  @Id @Column(name = &quot;PARENT_ID&quot;)\n  private String id;\n  private String name;\n  ...\n\n}\n\n@Entity\n@IdClass(ChildId.class)\npublic class Child {\n\n  @Id\n  @ManyToOne\n  @JoinColumn(name = &quot;PARENT_ID&quot;)\n  public Parent parent;\n\n  @Id @Column(name = &quot;CHILD_ID&quot;)\n  private String childId;\n\n  private String name;\n  ...\n\n}\n\n// 자식 ID\npublic class ChildId implements Serializable {\n\n  private String parent;\n  private String childId;\n\n  // equals, hashCode\n  ...\n\n}\n\n@Entity\n@IdClass(GrandChildId.class)\npublic class GrandChild {\n\n  @Id\n  @ManyToOne\n  @JoinColumns({\n          @JoinColumn(name = &quot;PARENT_ID&quot;),\n          @JoinColumn(name = &quot;CHILD_ID&quot;)\n  })\n  private Child child;\n\n  @Id @Column(name = &quot;GRANDCHILD_ID&quot;)\n  private String id;\n\n  private String name;\n  ...\n\n}\n\n// 손자 ID\npublic class GrandChildId implements Serializable {\n\n  private ChildId child;\n  private String id;\n\n  // equals, hashCode\n  ... \n\n}</code>\n        </deckgo-highlight-code>\n<ul>\n<li>식별 관계는 기본 키와 외래 키를 같이 매핑해야 한다. 따라서 식별자 매핑인 <code class=\"language-text\">@Id</code> 와 연관관계 매핑인 <code class=\"language-text\">@ManyToOne</code> 을 같이 사용한다.</li>\n<li><code class=\"language-text\">Child</code> 엔티티의 <code class=\"language-text\">parent</code> 필드에서 이를 구현하고 있다.</li>\n</ul>\n<p><strong><code class=\"language-text\">@EmbeddedId</code> 와 식별 관계</strong><br/>\n<code class=\"language-text\">@MapsId</code> 를 사용해야 한다.</p>\n<deckgo-highlight-code language=\"java\" terminal=\"carbon\" theme=\"a11y-dark\" line-numbers=\"true\"  >\n          <code slot=\"code\">@Entity\npublic class Parent {\n\n  @Id @Column(name = &quot;PARENT_ID&quot;)\n  private String id;\n\n  private String name;\n  ...\n\n}\n\n@Entity\npublic class Child {\n\n  @EmbeddedId\n  private String childId;\n\n  @MapsId(&quot;parentId&quot;)\n  @ManyToOne\n  @JoinColumn(name = &quot;PARENT_ID&quot;)\n  public Parent parent;\n\n  private String name;\n  ...\n\n}\n\n// 자식 ID\n@Embeddable\npublic class ChildId implements Serializable {\n\n  private String parentId;\n\n  @Column(name = &quot;CHILD_ID&quot;)\n  private String id;\n\n  // equals, hashCode\n  ...\n\n}\n\n@Entity\npublic class GrandChild {\n\n  @EmbeddedId\n  private GrandChildId id;\n\n  @MapsId(&quot;childId&quot;)\n  @ManyToOne\n  @JoinColumns({\n          @JoinColumn(name = &quot;PARENT_ID&quot;),\n          @JoinColumn(name = &quot;CHILD_ID&quot;)\n  })\n  private Child child;\n\n  private String name;\n  ...\n\n}\n\n// 손자 ID\n@Embeddable\npublic class GrandChildId implements Serializable {\n\n  private ChildId childId;\n\n  @Column(name = &quot;GRANDCHILD_ID&quot;)\n  private String id;\n\n  // equals, hashCode\n  ... \n\n}</code>\n        </deckgo-highlight-code>\n<ul>\n<li><code class=\"language-text\">@EmbeddedId</code> 는 식별 관계로 사용할 연관관계의 속성에 <code class=\"language-text\">@MapsId</code> 를 사용하면 된다. <code class=\"language-text\">Child</code> 엔티티의 <code class=\"language-text\">parent</code> 필드에서 이를 구현하고 있다.</li>\n</ul>\n<blockquote>\n<p><code class=\"language-text\">@IdClass</code> 와 다른 점은 <code class=\"language-text\">@Id</code> 대신 <code class=\"language-text\">@MapsId</code> 를 사용했다는 것이다. 이는 외래 키와 매핑한 연관관계를 기본 키에도 매핑하겠다는 뜻이다. 해당 annotation의 속성 값은 <code class=\"language-text\">@EmbeddedId</code> 를 사용한 식별자 클래스의 기본 키 필드를 지정하면 된다.</p>\n</blockquote>\n<h3>➰ 비식별 관계로 구현</h3>\n<p>위에서 예로 들었던 식별 관계 테이블을 비식별 관계로 변경해보자.</p>\n<deckgo-highlight-code language=\"java\" terminal=\"carbon\" theme=\"a11y-dark\" line-numbers=\"true\"  >\n          <code slot=\"code\">@Entity\npublic class Parent {\n\n  @Id @GeneratedValue \n  @Column(name = &quot;PARENT_ID&quot;)\n  private Long id;\n  private String name;\n  ...\n\n}\n\n@Entity\npublic class Child {\n\n  @Id @GeneratedValue\n  @Column(name = &quot;CHILD_ID&quot;)\n  private Long id;\n  private String name;\n\n  @ManyToOne\n  @JoinColumn(name = &quot;PARENT_ID&quot;)\n  private Parent parent;\n  ...\n\n}\n\n@Entity\npublic class GrandChild {\n\n  @Id @GeneratedValue\n  @Column(name = &quot;GRANDCHILD_ID&quot;)\n  private Long id;\n  private String name;\n\n  @ManyToOne\n  @JoinColumn(name = &quot;CHILD_ID&quot;)\n  private Child child;\n  ...\n\n}</code>\n        </deckgo-highlight-code>\n<ul>\n<li>식별 관계보다 매핑도 쉽고 단순하다. 그리고 복합 키가 없어 복합 키 클래스를 만들지 않아도 된다.</li>\n</ul>\n<h3>➰ 일대일 식별 관계</h3>\n<p>이는 자식 테이블의 기본 키 값으로 <strong>부모 테이블의 기본 키 값만 사용</strong>한다. </p>\n<ul>\n<li>부모 테이블의 기본 키가 복합 키가 아니라면, 자식 테이블의 기본 키는 복합 키로 구성하지 않아도 된다.</li>\n</ul>\n<deckgo-highlight-code language=\"java\" terminal=\"carbon\" theme=\"a11y-dark\" line-numbers=\"true\"  >\n          <code slot=\"code\">// 부모\n@Entity\npublic class Board {\n\n  @Id @GeneratedValue\n  @Column(name = &quot;BOARD_ID&quot;)\n  private Long id;\n\n  private String title;\n\n  @OneToOne(mappedBy = &quot;board&quot;)\n  private BoardDetail boardDetail;\n  ...\n\n}\n\n// 자식\n@Entity\npublic class BoardDetail {\n\n  @Id\n  private Long boardId;\n\n  @MapsId\n  @OneToOne\n  @JoinColumn(name = &quot;BOARD_ID&quot;)\n  private Board board;\n\n  private String content;\n  ...\n\n}</code>\n        </deckgo-highlight-code>\n<ul>\n<li>\n<p>위 자식 엔티티처럼 식별자가 단순히 컬럼 하나면, <code class=\"language-text\">@MapsId</code> 를 사용하고 속성 값은 비워두면 된다.</p>\n<ul>\n<li>이때 <code class=\"language-text\">@MapsId</code> 는 <code class=\"language-text\">@Id</code> 를 사용해 식별자로 지정한 <code class=\"language-text\">BoardDetail.boardId</code> 와 매핑된다.</li>\n</ul>\n</li>\n</ul>\n<h3>➰ 식별, 비식별 관계의 장단점</h3>\n<p>아래와 같은 이유로 데이터베이스 설계 관점에서 식별 관계보다는 비식별 관계를 선호한다.</p>\n<ul>\n<li>\n<p>식별 관계는 부모 테이블의 기본 키를 자식 테이블로 전파하면서 자식 테이블의 기본 키 컬럼이 점점 늘어나게 한다.</p>\n<ul>\n<li>이는 결국 조인 시의 SQL을 복잡하게 만들고, 기본 키 인덱스가 불필요하게 커질 수 있도록 한다.</li>\n</ul>\n</li>\n<li>식별 관계는 2개 이상의 컬럼을 합해 복합 기본 키를 만들어야 하는 경우가 많다.</li>\n<li>\n<p>식별 관계를 사용할 때, 기본 키로 비즈니스 의미가 있는 자연 키 컬럼을 조합하는 경우가 많다. 반면 비식별 관계의 기본 키는 비즈니스와 전혀 관계없는 대리 키를 주로 사용한다.</p>\n<ul>\n<li>비즈니스 요구사항은 시간이 지남에 따라 언젠가는 변하기에 식별 관계의 자연 키 컬럼들이 많이 전파될수록 변경이 어렵다.</li>\n</ul>\n</li>\n<li>식별관계는 부모 테이블의 기본 키를 자식 테이블의 기본 키로 사용해 테이블 구조가 유연하지 못하다.</li>\n</ul>\n<p>객체 관계 매핑 관점에서는 다음 이유로 비식별 관계를 선호한다.</p>\n<ul>\n<li>\n<p>일대일 관계를 제외하고 식별 관계는 2개 이상의 컬럼을 묶은 복합 기본 키를 사용한다. JPA에서 복합 키는 별도의 복합 키 클래스를 만들어 사용해야 한다.</p>\n<ul>\n<li>따라서 컬럼이 하나인 기본 키를 매핑하는 것보다 많은 노력이 필요하다.</li>\n</ul>\n</li>\n<li>비식별 관계의 기본 키는 주로 대리 키를 사용하는데, JPA는 <code class=\"language-text\">@GeneratedValue</code> 와 같은 편리한 방법을 제공한다.</li>\n</ul>\n<p>물론 식별 관계의 장점도 있다.</p>\n<ul>\n<li>기본 키 인덱스의 활용성이 좋고,</li>\n<li>상위 테이블들의 기본 키 컬럼을 자식, 손자 테이블들이 가지고 있어 특정 상황에 조인 없이 하위 테이블만으로 검색을 완료할 수 있다.</li>\n</ul>\n<blockquote>\n<p>ORM 신규 프로젝트 진행 시 추천하는 방법은 가능한 <strong>비식별 관계를 사용하고 기본 키는 <code class=\"language-text\">Long</code> 타입의 대리 키를 사용하는 것</strong>이다.</p>\n</blockquote>\n<hr>\n<h2>💫 조인 테이블</h2>\n<p>데이터베이스 테이블의 연관관계를 설계하는 방법은 크게 2가지다.</p>\n<ul>\n<li>조인 컬럼 사용(외래 키)</li>\n<li>조인 테이블 사용(테이블 사용)</li>\n</ul>\n<p><strong>조인 컬럼 사용</strong><br/>\n테이블 간에 관계는 주로 조인 컬럼이라 부르는 외래 키 컬럼을 사용해서 관리한다. </p>\n<p>예를 들어 회원과 사물함이 있다. </p>\n<ul>\n<li>\n<p>회원이 원할 때 사물함을 선택할 수 있다는 가정이 있다면, 회원이 사물함을 사용하기 전까진 둘 사이에 관계가 없어 <code class=\"language-text\">MEMBER</code> 테이블의 <code class=\"language-text\">LOCKER_ID</code> 외래 키에는 <code class=\"language-text\">null</code> 값을 입력해야 한다.</p>\n<ul>\n<li>이렇게 외래 키에 <code class=\"language-text\">null</code> 을 허용하는 관계를 이전에 <strong>선택적 비식별 관계</strong>라 했다.</li>\n</ul>\n</li>\n</ul>\n<p>선택적 비식별 관계는 이러한 특성으로 조인 시 <strong>외부 조인(OUTER JOIN)</strong>을 사용해야 한다.</p>\n<p><strong>조인 테이블 사용</strong><br/>\n별도의 테이블을 사용해서 연관관계를 관리하는 방법이다.</p>\n<p>조인 컬럼을 사용하는 방법은 단순히 외래 키 컬럼만 추가해 연관관계를 맺지만, 조인 테이블을 사용하는 방법은 연관관계를 관리하는 조인 테이블을 추가하고, 여기서 두 테이블의 외래 키를 가지고 연관관계를 관리한다.</p>\n<ul>\n<li>따라서, <strong>두 테이블에는 연관관계 관리를 위한 외래 키 컬럼이 없다.</strong></li>\n</ul>\n<p>추가적인 테이블을 생성해야 한다는 것이 가장 큰 단점이다.</p>\n<ul>\n<li>관리해야 할 테이블이 늘어나고, 두 테이블의 조인을 위해 총 3개의 테이블이 조인되어야 한다. </li>\n</ul>\n<blockquote>\n<p>객체와 테이블을 매핑할 때 조인 컬럼 -> <code class=\"language-text\">@JoinColumn</code> , 조인 테이블 -> <code class=\"language-text\">@JoinTable</code> 로 매핑한다.</p>\n</blockquote>\n<h3>➰ 일대일 조인 테이블</h3>\n<p>(두 테이블의) 일대일 관계를 관리하기 위해서는 조인 테이블의 외래 키 컬럼 각각에 총 2개의 유니크 제약조건을 걸어야 한다. (<code class=\"language-text\">PARENT</code> - <code class=\"language-text\">PARENT_CHILD</code> , <code class=\"language-text\">CHILD</code>)</p>\n<deckgo-highlight-code language=\"java\" terminal=\"carbon\" theme=\"a11y-dark\" line-numbers=\"true\"  >\n          <code slot=\"code\">@Entity\npublic class Parent {\n\n  @Id @GeneratedValue\n  @Column(name = &quot;PARENT_ID&quot;)\n  private Long id;\n  private String name;\n\n  @OneToOne\n  @JoinTable(name = &quot;PARENT_CHILD&quot;,\n          joinColumns = @JoinColumn(name = &quot;PARENT_ID&quot;),\n          inverserJoinColumns = @JoinColumn(name = &quot;CHILD_ID&quot;)\n  )\n  private Child child;\n  ...\n\n}\n\n@Entity\npublic class Child {\n\n  @Id @GeneratedValue\n  @Column(name = &quot;CHLID_ID&quot;)\n  private Long id;\n  private String name;\n  ...\n\n}</code>\n        </deckgo-highlight-code>\n<ul>\n<li>\n<p>부모 엔티티는 <code class=\"language-text\">@JoinTable</code> 을 사용하고 있다.</p>\n<ul>\n<li><code class=\"language-text\">name</code> : 매핑할 조인 테이블 이름</li>\n<li><code class=\"language-text\">joinColumns</code> : 현재 엔티티를 참조하는 외래 키</li>\n<li><code class=\"language-text\">inverseJoinColumns</code> : 반대방향 엔티티를 참조하는 외래 키</li>\n</ul>\n</li>\n</ul>\n<blockquote>\n<p>양방향 매핑을 위해서는 자식 엔티티에 <code class=\"language-text\">parent</code> 필드를 생성하고, <code class=\"language-text\">@OneToOne</code> annotation을 사용하면 된다.</p>\n</blockquote>\n<h3>➰ 일대다 조인 테이블</h3>\n<p>일대다 관계를 만들려면 조인 테이블의 컬럼 중 <strong>다(N)와 관련된 컬럼에 유니크 제약조건</strong>을 걸어야 한다.</p>\n<deckgo-highlight-code language=\"java\" terminal=\"carbon\" theme=\"a11y-dark\" line-numbers=\"true\"  >\n          <code slot=\"code\">@Entity\npublic class Parent {\n\n  @Id @GeneratedValue\n  @Column(name = &quot;PARENT_ID&quot;)\n  private Long id;\n  private String name;\n\n  @OneToMany\n  @JoinTable(name = &quot;PARENT_CHILD&quot;,\n          joinColumns = @JoinColumn(name = &quot;PARENT_ID&quot;),\n          inverserJoinColumns = @JoinColumn(name = &quot;CHILD_ID&quot;)\n  )\n  private List&lt;Child&gt; child = new ArrayList&lt;&gt;();\n  ...\n\n}\n\n@Entity\npublic class Child {\n\n  @Id @GeneratedValue\n  @Column(name = &quot;CHLID_ID&quot;)\n  private Long id;\n  private String name;\n  ...\n\n}</code>\n        </deckgo-highlight-code>\n<h3>➰ 다대일 조인 테이블</h3>\n<p>일대다에서 방향만 반대이다!</p>\n<deckgo-highlight-code language=\"java\" terminal=\"carbon\" theme=\"a11y-dark\" line-numbers=\"true\"  >\n          <code slot=\"code\">@Entity\npublic class Parent {\n\n  @Id @GeneratedValue\n  @Column(name = &quot;PARENT_ID&quot;)\n  private Long id;\n  private String name;\n\n  @OneToMany(mappedBy = &quot;parent&quot;)\n  private List&lt;Child&gt; child = new ArrayList&lt;&gt;();\n  ...\n\n}\n\n@Entity\npublic class Child {\n\n  @Id @GeneratedValue\n  @Column(name = &quot;CHLID_ID&quot;)\n  private Long id;\n  private String name;\n\n  @ManyToOne(optional = false)\n  @JoinTable(name = &quot;PARENT_CHILD&quot;,\n          joinColumns = @JoinColumn(name = &quot;CHILD_ID&quot;),\n          inverserJoinColumns = @JoinColumn(name = &quot;PARENT_ID&quot;)\n  )\n  private Parent parent;\n  ...\n\n}</code>\n        </deckgo-highlight-code>\n<h3>➰ 다대다 조인 테이블</h3>\n<p>다대다 관계를 만들기 위해서는 조인 테이블의 두 컬럼을 합해 하나의 복합 유니크 제약조건을 걸어야 한다.</p>\n<deckgo-highlight-code language=\"java\" terminal=\"carbon\" theme=\"a11y-dark\" line-numbers=\"true\"  >\n          <code slot=\"code\">@Entity\npublic class Parent {\n\n  @Id @GeneratedValue\n  @Column(name = &quot;PARENT_ID&quot;)\n  private Long id;\n  private String name;\n\n  @ManyToMany\n  @JoinTable(name = &quot;PARENT_CHILD&quot;,\n          joinColumns = @JoinColumn(name = &quot;PARENT_ID&quot;),\n          inverserJoinColumns = @JoinColumn(name = &quot;CHILD_ID&quot;)\n  )\n  private List&lt;Child&gt; child = new ArrayList&lt;&gt;();\n  ...\n\n}\n\n@Entity\npublic class Child {\n\n  @Id @GeneratedValue\n  @Column(name = &quot;CHLID_ID&quot;)\n  private Long id;\n  private String name;\n  ...\n\n}</code>\n        </deckgo-highlight-code>\n<blockquote>\n<p>조인 테이블에 컬럼을 추가하면 <code class=\"language-text\">@JoinTable</code> 전략을 사용할 수 없다. 대신 새로운 엔티티를 만들어 조인 테이블과 매핑해야 한다.</p>\n</blockquote>\n<hr>\n<h2>💫 엔티티 하나에 여러 테이블 매핑</h2>\n<p>잘 사용하지는 않지만 <code class=\"language-text\">@SecondaryTable</code> 을 사용하면 한 엔티티에 여러 테이블을 매핑할 수 있다.</p>\n<deckgo-highlight-code language=\"java\" terminal=\"carbon\" theme=\"a11y-dark\" line-numbers=\"true\"  >\n          <code slot=\"code\">@Entity\n@Table(name = &quot;BOARD&quot;)\n@SecondaryTable(name = &quot;BOARD_DETAIL&quot;,\n    pkJoinColumns = @PrimaryKeyJoinColumn(name = &quot;BOARD_DETAIL_ID&quot;))\npublic class Board {\n\n  @Id @GeneratedValue\n  @Column(name = &quot;BOARD_ID&quot;)\n  private Long id;\n\n  private String title;\n\n  @Column(table = &quot;BOARD_DETAIL&quot;)\n  private String content;\n  ...\n\n}</code>\n        </deckgo-highlight-code>\n<ul>\n<li>\n<p><code class=\"language-text\">Board</code> 엔티티는 <code class=\"language-text\">@Table</code> 로 <code class=\"language-text\">BOARD</code> 테이블과 매핑했고, 추가로 <code class=\"language-text\">@SecondaryTable</code> 를 사용해 <code class=\"language-text\">BOARD_DETAIL</code> 테이블과 매핑했다.</p>\n<ul>\n<li><code class=\"language-text\">@SecondaryTable.name</code> : 매핑할 다른 테이블의 이름</li>\n<li><code class=\"language-text\">@SecondaryTable. pkJoinColumns</code> : 매핑할 다른 테이블의 기본 키 컬럼 속성</li>\n</ul>\n</li>\n<li><code class=\"language-text\">@SecondaryTables</code> 에 <code class=\"language-text\">@SecondaryTable</code> 를 여러 개 사용하여 추가로 테이블들과 매핑할 수도 있다.</li>\n</ul>\n<blockquote>\n<p>하나의 엔티티에 여러 테이블을 매핑하는 것은 항상 두 테이블을 조회하기에 최적화가 어렵다. 따라서 테이블당 엔티티를 생성해 일대일 매핑하는 것을 권장한다.</p>\n</blockquote>\n<h2>📕 출처</h2>\n<p><strong>자바 ORM 표준 JPA 프로그래밍</strong> - 김영한</p>","frontmatter":{"title":"📚 7. 고급 매핑","date":"March 17, 2022","update":"March 18, 2022","tags":["Java","JPA","SpringBoot"],"series":"📚 ORM 표준 JPA"},"fields":{"slug":"/[JPA]7/","readingTime":{"minutes":32.42}}},"seriesList":{"edges":[{"node":{"id":"66d0397b-0a88-53f8-9e40-01878853acdd","fields":{"slug":"/[JPA]1/"},"frontmatter":{"title":"📚 1. JPA 소개"}}},{"node":{"id":"f86fa867-f096-52ce-854a-ef00e49ebcdb","fields":{"slug":"/[JPA]2/"},"frontmatter":{"title":"📚 2. JPA 시작"}}},{"node":{"id":"ffb8392d-d300-51c1-8e71-a8943ef4b58d","fields":{"slug":"/[JPA]3/"},"frontmatter":{"title":"📚 3. 영속성 관리"}}},{"node":{"id":"f45d0c27-c0da-5191-8c86-2aef34b75f27","fields":{"slug":"/[JPA]4/"},"frontmatter":{"title":"📚 4. 엔티티 매핑"}}},{"node":{"id":"c710307c-927c-5c1b-80fb-c45a4ff20616","fields":{"slug":"/[JPA]5/"},"frontmatter":{"title":"📚 5. 연관관계 매핑 기초"}}},{"node":{"id":"24c890e9-eebe-56bf-9db2-8660dcb3b783","fields":{"slug":"/[JPA]6/"},"frontmatter":{"title":"📚 6. 다양한 연관관계 매핑"}}},{"node":{"id":"26e75089-52ac-5b50-98c9-c2806068b034","fields":{"slug":"/[JPA]7/"},"frontmatter":{"title":"📚 7. 고급 매핑"}}},{"node":{"id":"ac8c493e-a661-53a5-989d-b84fcb728ed1","fields":{"slug":"/[JPA]8/"},"frontmatter":{"title":"📚 8. 프록시와 연관관계 관리"}}},{"node":{"id":"5003d7a8-381f-550d-aecd-28caba14aba9","fields":{"slug":"/[JPA]9/"},"frontmatter":{"title":"📚 9. 값 타입"}}},{"node":{"id":"a41dc548-d976-533a-a680-96e86a627d35","fields":{"slug":"/[JPA]10/"},"frontmatter":{"title":"📚 10. 객체지향 쿼리 언어"}}},{"node":{"id":"4ef1a134-ac1d-5e69-9f85-7c1b5d7a8244","fields":{"slug":"/[JPA]11/"},"frontmatter":{"title":"📚 11. 웹 애플리케이션 제작"}}},{"node":{"id":"1a74ae89-3758-5cb9-938c-b8238d176c8c","fields":{"slug":"/[JPA]12/"},"frontmatter":{"title":"📚 12. 스프링 데이터 JPA"}}},{"node":{"id":"5900f638-1417-5a4a-a147-a228540a920b","fields":{"slug":"/[JPA]13/"},"frontmatter":{"title":"📚 13. 웹 애플리케이션과 영속성 관리"}}},{"node":{"id":"5f07d9ea-eadc-54ea-90b2-efe93297170f","fields":{"slug":"/[JPA]14/"},"frontmatter":{"title":"📚 14. 컬렉션과 부가 기능"}}},{"node":{"id":"838bd515-9bd3-5d4b-8f49-723d3f55688c","fields":{"slug":"/[JPA]15/"},"frontmatter":{"title":"📚 15. 고급 주제와 성능 최적화"}}},{"node":{"id":"1f449b33-36ba-58f9-915f-be058ee6ba3e","fields":{"slug":"/[JPA]16/"},"frontmatter":{"title":"📚 16. 트랜잭션과 락, 2차 캐시"}}}]},"previous":{"fields":{"slug":"/[JPA]6/"},"frontmatter":{"title":"📚 6. 다양한 연관관계 매핑"}},"next":{"fields":{"slug":"/[BOJ]3190/"},"frontmatter":{"title":"👩‍💻 3190. 뱀"}}},"pageContext":{"id":"26e75089-52ac-5b50-98c9-c2806068b034","series":"📚 ORM 표준 JPA","previousPostId":"24c890e9-eebe-56bf-9db2-8660dcb3b783","nextPostId":"883b6ecf-7528-5c16-92fa-edf12a64e80e"}},"staticQueryHashes":[]}